/*
 * ./src/special_opt.c
 * Copyright (C) 2009 lameire alexis
 * 
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <http://www.gnu.org/licenses/>.
 */
#include <getopt.h>
#include <libintl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include "special_opt.h"
#include "fonction_algo.h"
#define _(STRING)            gettext(STRING)

void parse_args(int argc, char **argv)
{
	int c;
	int index;
	static struct option long_options[] = {
		{"create-initial-db", no_argument, 0, 'd'},
		{"import-csv", required_argument, 0, 'i'},
		{"export-csv", required_argument, 0, 'e'},
		{0, 0, 0, 0}
	};
	while ((c = getopt_long(argc, argv, "di:e:", long_options, &index)) != -1)
	{
		switch (c)
		{
		case 'd':
			create_initiale_db();
			break;
		case 'i':
			import_csv(optarg);
			break;
		case 'e':
			export_csv(optarg);
			break;
		case '?':
			if (isprint(optopt))
			{
				fprintf(stderr, _("ERREUR : Option -%c non reconnue"), optopt);
			}
			else
			{
				fprintf(stderr, _("ERREUR : caractère d'option non imprimable"));
			}
			break;
		}
	}
}

void create_initiale_db(void)
{
	sqlite3 *db = NULL;

	//ouverture de la db
	if (sqlite3_open_v2("DB", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL) != SQLITE_OK)
	{
		fprintf(stderr, _("ERREUR : Impossible d'ouvrir la BDD : fermeture\n"));
		fprintf(stderr, "%s\n", sqlite3_errmsg(db));
		exit(EXIT_FAILURE);
	}
	else
	{
		char *msg_erreur;
		int erreur = sqlite3_exec(db,
					  "CREATE TABLE \"categorie\" ("
					  "	\"id\" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
					  "	\"categorie\" TEXT NOT NULL UNIQUE"
					  ");"
					  "CREATE TABLE \"mots\" ("
					  "	\"id\" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
					  "	\"mot\" TEXT NOT NULL,"
					  "	\"id_cat\" INTEGER NOT NULL,"
					  "	\"deja_tire\" INTEGER DEFAULT (0)"
					  ");"
					  "CREATE TABLE \"utilisateur\" ("
					  "	\"id\" INTEGER PRIMARY KEY AUTOINCREMENT,"
					  "	\"pseudo\" TEXT NOT NULL UNIQUE,"
					  "	\"score\" INTEGER DEFAULT (0),"
					  "	\"hl_me\" INTEGER DEFAULT (0)"
					  ");"
					  "INSERT INTO categorie(categorie) VALUES('defaut');"
					  "INSERT INTO mots(mot, id_cat) VALUES('defaut', 1);", NULL, NULL, &msg_erreur);
		if (erreur == SQLITE_OK)
		{
			printf(_("Base de données créee avec succés.\n"));
			sqlite3_close(db);
			exit(EXIT_SUCCESS);
		}
		else
		{
			fprintf(stderr, _("Erreur de création de la BDD : %s\n"), msg_erreur);
			sqlite3_close(db);
			sqlite3_free(msg_erreur);
			exit(EXIT_FAILURE);
		}
	}
}

void import_csv(char *categorie)
{
	sqlite3 *db = NULL;
	char *nom_fichier_csv = (char *) g_strdup_printf("%s.csv", categorie);
	if (access(nom_fichier_csv, R_OK) == -1)
	{
		fprintf(stderr, _("ERREUR : Fichier inexistant\n"));
		exit(EXIT_FAILURE);
	}
	else
	{
		if (sqlite3_open_v2("DB", &db, SQLITE_OPEN_READWRITE, NULL) != SQLITE_OK)
		{
			g_free(nom_fichier_csv);
			fprintf(stderr, _("ERREUR : Impossible d'ouvrir la BDD\n%s\n"), sqlite3_errmsg(db));
			exit(EXIT_FAILURE);
		}
		else
		{
			int nb_row = 0;
			int erreur = 0;
			char *err_msg = NULL;
			char *requette = (char *) g_strdup_printf("SELECT * FROM categorie WHERE categorie='%s'", categorie);

			printf(_("DEBUG : Pointeur nb_row %p   %d\n"), &nb_row, nb_row);
			erreur = sqlite3_exec(db, requette, compter_colonnes, &nb_row, &err_msg);;
			g_free(requette);

			if (nb_row == 1)
			{
				fprintf(stderr, _("ERREUR : La catégorie existe\n"));
				sqlite3_free(err_msg);
				sqlite3_close(db);
				g_free(nom_fichier_csv);
				exit(EXIT_FAILURE);
			}
			else if (nb_row == 0)
			{
				FILE *fichier = fopen(nom_fichier_csv, "r");
				if (fichier == NULL)
				{
					fprintf(stderr, _("ERREUR : Impossible d'ouvrir le fichier de configuration\n"));
					sqlite3_close(db);
					g_free(nom_fichier_csv);
					exit(EXIT_FAILURE);
				}
				else
				{
					requette = (char *) g_strdup_printf("INSERT INTO categorie(categorie)  VALUES('%s')", categorie);
					erreur = sqlite3_exec(db, requette, NULL, NULL, &err_msg);
					g_free(requette);
					if (erreur != SQLITE_OK)
					{
						fprintf(stderr, _("Erreur lors de la création de la catégorie.\n%s\n"), err_msg);
						sqlite3_free(err_msg);
						sqlite3_close(db);
						g_free(nom_fichier_csv);
						exit(EXIT_FAILURE);
					}
					else
					{
						int taille_mot = -1;
						char *mot = NULL;
						sqlite3_stmt *requette = NULL;

						erreur = sqlite3_prepare_v2(db, "INSERT INTO mots(id_cat, mot)"
									    "VALUES("
									    "	   (SELECT id FROM categorie WHERE categorie=?)"
									    "	   , ?" ")", -1, &requette, NULL);
						if (erreur != SQLITE_OK)
						{
							fprintf(stderr, _("ERREUR : Impossible de préparer la requête \n"));
							sqlite3_close(db);
							fclose(fichier);
							g_free(nom_fichier_csv);
							exit(EXIT_FAILURE);
						}
						else
						{
							while ((taille_mot = compter(fichier, '\n')) != 0)
							{
								mot = recuperer(fichier, taille_mot);
								sqlite3_bind_text(requette, 1, categorie, -1, SQLITE_STATIC);
								sqlite3_bind_text(requette, 2, mot, -1, free);
								sqlite3_step(requette);
								sqlite3_reset(requette);
								fseek(fichier, SEEK_CUR, 1);
							}
							sqlite3_finalize(requette);
							sqlite3_close(db);
							fclose(fichier);
							free(categorie);
							printf(_("Le fichier CSV a été correctement importé.\n"));
							exit(EXIT_SUCCESS);
						}
					}
				}
			}
			else
			{
				fprintf(stderr, _("ERREUR : La base de données est corrompue\n"));
				sqlite3_close(db);
				g_free(nom_fichier_csv);
				exit(EXIT_FAILURE);
			}
		}
	}
}

void export_csv(char *categorie)
{
	sqlite3 *db = NULL;
	if (sqlite3_open_v2("DB", &db, SQLITE_OPEN_READWRITE, NULL) != SQLITE_OK)
	{
		fprintf(stderr, _("ERREUR : Impossible d'ouvrir la BDD\n%s\n"), sqlite3_errmsg(db));
		exit(EXIT_FAILURE);
	}
	else
	{

		sqlite3_stmt *requette = NULL;
		if (!strcmp(categorie, "ALL"))
		{
			sqlite3_prepare_v2(db, "SELECT * FROM categorie", -1, &requette, NULL);
			while (sqlite3_step(requette) == SQLITE_ROW)
			{
				int id_cat = sqlite3_column_int(requette, 0);
				const char *categorie = sqlite3_column_text(requette, 1);
				cree_csv(db, id_cat, categorie);
			}
			sqlite3_finalize(requette);
			sqlite3_close(db);
			printf(_("Les fichiers ont bien été exportés.\n"));
		}
		else
		{
			sqlite3_prepare(db, "SELECT * FROM categorie WHERE categorie=?", -1, &requette, NULL);
			sqlite3_bind_text(requette, 1, categorie, -1, SQLITE_STATIC);
			if (sqlite3_step(requette) == SQLITE_ROW)
			{
				int id_cat = sqlite3_column_int(requette, 0);
				sqlite3_finalize(requette);
				cree_csv(db, id_cat, categorie);
				sqlite3_close(db);
			}
			else if (sqlite3_step(requette) == SQLITE_DONE)
			{
				fprintf(stderr, _("ERREUR : Catégorie inexistante\n"));
				sqlite3_finalize(requette);
				sqlite3_close(db);
				exit(EXIT_FAILURE);
			}
		}
	}
}

void cree_csv(sqlite3 * db, int id_cat, const char *categorie)
{
	sqlite3_stmt *requette = NULL;
	char *nom_fichier = (char *) g_strdup_printf("%s.csv", categorie);
	FILE *fichier = NULL;

	if (access(nom_fichier, R_OK) != -1)
	{
		fprintf(stderr, _("ERREUR : Le fichier %s existe : ignorée\n"));
		return;
	}
	else
	{
		fichier = fopen(nom_fichier, "w");
		g_free(nom_fichier);
		if (fichier == NULL)
		{
			fprintf(stderr, _("ERREUR : Impossible d'ouvrir le fichier\n"));
			exit(EXIT_FAILURE);
		}
		else
		{
			sqlite3_prepare_v2(db, "SELECT mot FROM mots WHERE id_cat=? ORDER BY mot DESC", -1, &requette, NULL);
			sqlite3_bind_int(requette, 1, id_cat);
			while (sqlite3_step(requette) == SQLITE_ROW)
			{
				fprintf(fichier, "%s\n", sqlite3_column_text(requette, 0));
			}
			sqlite3_finalize(requette);
			fclose(fichier);
			printf(_("Catégorie %s exportée.\n"), categorie);
			return;
		}
	}
}
